"""
命令行界面模块
提供用户交互界面和命令处理
"""

import sys
import argparse
import os
from typing import List, Optional, Dict, Any
from datetime import datetime

from services.task_service import TaskService
from models.database import DatabaseManager
from config.settings import settings
from utils.helpers import format_date, truncate_text, parse_date_input
from utils.validators import validate_task_id, validate_search_keyword
from utils.data_manager import DataManager


class TaskCLI:
    """任务管理命令行界面"""
    
    def __init__(self, task_service: Optional[TaskService] = None):
        """
        初始化 CLI
        
        Args:
            task_service: 任务服务实例
        """
        if task_service:
            self.task_service = task_service
        else:
            db_manager = DatabaseManager(settings.get_database_path())
            self.task_service = TaskService(db_manager)
        
        self.parser = self._create_parser()
        self.data_manager = DataManager(self.task_service)
    
    def _create_parser(self) -> argparse.ArgumentParser:
        """创建命令行参数解析器"""
        parser = argparse.ArgumentParser(
            description='个人任务管理器',
            formatter_class=argparse.RawDescriptionHelpFormatter,
            epilog="""
示例用法:
  python main.py add "学习Python" -p high -c 学习 -d 2024-12-31
  python main.py list --status todo
  python main.py edit 1 -t "新标题" -p medium
  python main.py complete 1
  python main.py search "Python"
  python main.py stats
  python main.py import tasks.json --mode update
  python main.py backup -o backup.zip
  python main.py report summary
            """
        )
        
        subparsers = parser.add_subparsers(dest='command', help='可用命令')
        
        # 添加任务命令
        add_parser = subparsers.add_parser('add', help='添加新任务')
        add_parser.add_argument('title', help='任务标题')
        add_parser.add_argument('-d', '--description', help='任务描述')
        add_parser.add_argument('-p', '--priority', choices=['high', 'medium', 'low'], 
                               default='medium', help='优先级 (默认: medium)')
        add_parser.add_argument('-c', '--category', help='任务分类')
        add_parser.add_argument('--due-date', help='截止日期 (YYYY-MM-DD)')
        
        # 列出任务命令
        list_parser = subparsers.add_parser('list', help='查看任务列表')
        list_parser.add_argument('--status', choices=['todo', 'in_progress', 'completed'], 
                                help='按状态过滤')
        list_parser.add_argument('--priority', choices=['high', 'medium', 'low'], 
                                help='按优先级过滤')
        list_parser.add_argument('--category', help='按分类过滤')
        list_parser.add_argument('--sort', choices=['id', 'title', 'priority', 'due_date', 'created_at'], 
                                default='created_at', help='排序字段 (默认: created_at)')
        list_parser.add_argument('--reverse', action='store_true', help='倒序排列')
        list_parser.add_argument('--limit', type=int, default=20, help='显示数量限制 (默认: 20)')
        list_parser.add_argument('--page', type=int, default=1, help='页码 (默认: 1)')
        list_parser.add_argument('--overdue', action='store_true', help='只显示过期任务')
        list_parser.add_argument('--upcoming', type=int, metavar='DAYS', help='显示未来N天内到期的任务')
        list_parser.add_argument('--today', action='store_true', help='只显示今天的任务')
        list_parser.add_argument('--date-from', help='截止日期起始范围 (YYYY-MM-DD)')
        list_parser.add_argument('--date-to', help='截止日期结束范围 (YYYY-MM-DD)')
        
        # 编辑任务命令
        edit_parser = subparsers.add_parser('edit', help='编辑任务')
        edit_parser.add_argument('id', type=int, help='任务 ID')
        edit_parser.add_argument('-t', '--title', help='新标题')
        edit_parser.add_argument('-d', '--description', help='新描述')
        edit_parser.add_argument('-p', '--priority', choices=['high', 'medium', 'low'], 
                                help='新优先级')
        edit_parser.add_argument('-s', '--status', choices=['todo', 'in_progress', 'completed'], 
                                help='新状态')
        edit_parser.add_argument('-c', '--category', help='新分类')
        edit_parser.add_argument('--due-date', help='新截止日期 (YYYY-MM-DD)')
        
        # 删除任务命令
        delete_parser = subparsers.add_parser('delete', help='删除任务')
        delete_parser.add_argument('id', type=int, help='任务 ID')
        delete_parser.add_argument('-f', '--force', action='store_true', help='强制删除，不询问确认')
        
        # 完成任务命令
        complete_parser = subparsers.add_parser('complete', help='标记任务完成')
        complete_parser.add_argument('id', type=int, help='任务 ID')
        
        # 开始任务命令
        start_parser = subparsers.add_parser('start', help='开始任务')
        start_parser.add_argument('id', type=int, help='任务 ID')
        
        # 重新打开任务命令
        reopen_parser = subparsers.add_parser('reopen', help='重新打开任务')
        reopen_parser.add_argument('id', type=int, help='任务 ID')
        
        # 搜索任务命令
        search_parser = subparsers.add_parser('search', help='搜索任务')
        search_parser.add_argument('keyword', help='搜索关键词')
        search_parser.add_argument('--limit', type=int, default=10, help='显示数量限制 (默认: 10)')
        search_parser.add_argument('--fields', nargs='+', choices=['title', 'description'], 
                                  default=['title', 'description'], help='搜索字段')
        search_parser.add_argument('--status', choices=['todo', 'in_progress', 'completed'], 
                                  help='同时按状态过滤')
        search_parser.add_argument('--priority', choices=['high', 'medium', 'low'], 
                                  help='同时按优先级过滤')
        
        # 高级查询命令
        filter_parser = subparsers.add_parser('filter', help='高级过滤查询')
        filter_parser.add_argument('--status', nargs='+', choices=['todo', 'in_progress', 'completed'], 
                                  help='状态列表')
        filter_parser.add_argument('--priority', nargs='+', choices=['high', 'medium', 'low'], 
                                  help='优先级列表')
        filter_parser.add_argument('--category', nargs='+', help='分类列表')
        filter_parser.add_argument('--keyword', help='搜索关键词')
        filter_parser.add_argument('--date-from', help='截止日期起始 (YYYY-MM-DD)')
        filter_parser.add_argument('--date-to', help='截止日期结束 (YYYY-MM-DD)')
        filter_parser.add_argument('--overdue', action='store_true', help='过期任务')
        filter_parser.add_argument('--upcoming', type=int, metavar='DAYS', help='未来N天内到期')
        filter_parser.add_argument('--today', action='store_true', help='今天的任务')
        filter_parser.add_argument('--sort', choices=['id', 'title', 'priority', 'due_date', 'created_at'], 
                                  default='created_at', help='排序字段')
        filter_parser.add_argument('--reverse', action='store_true', help='倒序排列')
        filter_parser.add_argument('--limit', type=int, default=20, help='显示数量限制')
        filter_parser.add_argument('--page', type=int, default=1, help='页码')
        
        # 显示任务详情命令
        show_parser = subparsers.add_parser('show', help='显示任务详情')
        show_parser.add_argument('id', type=int, help='任务 ID')
        
        # 统计信息命令
        stats_parser = subparsers.add_parser('stats', help='显示统计信息')
        
        # 导出任务命令
        export_parser = subparsers.add_parser('export', help='导出任务数据')
        export_parser.add_argument('format', choices=['json', 'csv'], help='导出格式')
        export_parser.add_argument('-o', '--output', help='输出文件路径')
        
        # 清理已完成任务命令
        clean_parser = subparsers.add_parser('clean', help='清理已完成的任务')
        clean_parser.add_argument('-f', '--force', action='store_true', help='强制清理，不询问确认')
        
        # 交互模式命令
        interactive_parser = subparsers.add_parser('interactive', help='进入交互模式')
        
        # 数据导入命令
        import_parser = subparsers.add_parser('import', help='导入任务数据')
        import_parser.add_argument('file', help='导入文件路径')
        import_parser.add_argument('--format', choices=['json', 'csv'], help='文件格式（自动检测）')
        import_parser.add_argument('--mode', choices=['skip', 'update', 'replace'], 
                                  default='skip', help='合并模式 (默认: skip)')
        
        # 数据备份命令
        backup_parser = subparsers.add_parser('backup', help='创建数据备份')
        backup_parser.add_argument('-o', '--output', help='备份文件路径')
        
        # 数据恢复命令
        restore_parser = subparsers.add_parser('restore', help='恢复数据备份')
        restore_parser.add_argument('file', help='备份文件路径')
        restore_parser.add_argument('--mode', choices=['merge', 'replace'], 
                                   default='merge', help='恢复模式 (默认: merge)')
        
        # 数据报告命令
        report_parser = subparsers.add_parser('report', help='生成数据报告')
        report_parser.add_argument('type', choices=['summary', 'detailed', 'productivity'], 
                                  help='报告类型')
        report_parser.add_argument('-o', '--output', help='输出文件路径')
        report_parser.add_argument('--format', choices=['json', 'txt'], 
                                  default='txt', help='输出格式 (默认: txt)')
        
        # 数据库维护命令
        maintain_parser = subparsers.add_parser('maintain', help='数据库维护')
        maintain_parser.add_argument('--cleanup', action='store_true', help='清理数据库')
        maintain_parser.add_argument('--optimize', action='store_true', help='优化数据库')
        
        return parser
    
    def run(self, args: Optional[List[str]] = None) -> int:
        """
        运行 CLI
        
        Args:
            args: 命令行参数列表
            
        Returns:
            退出码
        """
        try:
            if args is None:
                args = sys.argv[1:]
            
            # 如果没有参数，显示帮助信息
            if not args:
                self.parser.print_help()
                return 0
            
            parsed_args = self.parser.parse_args(args)
            
            # 根据命令调用相应的处理方法
            if parsed_args.command == 'add':
                return self._handle_add(parsed_args)
            elif parsed_args.command == 'list':
                return self._handle_list(parsed_args)
            elif parsed_args.command == 'edit':
                return self._handle_edit(parsed_args)
            elif parsed_args.command == 'delete':
                return self._handle_delete(parsed_args)
            elif parsed_args.command == 'complete':
                return self._handle_complete(parsed_args)
            elif parsed_args.command == 'start':
                return self._handle_start(parsed_args)
            elif parsed_args.command == 'reopen':
                return self._handle_reopen(parsed_args)
            elif parsed_args.command == 'search':
                return self._handle_search(parsed_args)
            elif parsed_args.command == 'filter':
                return self._handle_filter(parsed_args)
            elif parsed_args.command == 'show':
                return self._handle_show(parsed_args)
            elif parsed_args.command == 'stats':
                return self._handle_stats(parsed_args)
            elif parsed_args.command == 'export':
                return self._handle_export(parsed_args)
            elif parsed_args.command == 'clean':
                return self._handle_clean(parsed_args)
            elif parsed_args.command == 'interactive':
                return self._handle_interactive(parsed_args)
            elif parsed_args.command == 'import':
                return self._handle_import(parsed_args)
            elif parsed_args.command == 'backup':
                return self._handle_backup(parsed_args)
            elif parsed_args.command == 'restore':
                return self._handle_restore(parsed_args)
            elif parsed_args.command == 'report':
                return self._handle_report(parsed_args)
            elif parsed_args.command == 'maintain':
                return self._handle_maintain(parsed_args)
            else:
                self.parser.print_help()
                return 1
                
        except KeyboardInterrupt:
            print("\n\n👋 再见！")
            return 0
        except Exception as e:
            print(f"❌ 错误: {str(e)}")
            return 1
    
    def _handle_add(self, args) -> int:
        """处理添加任务命令"""
        try:
            # 解析截止日期
            due_date = None
            if args.due_date:
                due_date = parse_date_input(args.due_date)
                if not due_date:
                    print(f"❌ 无效的日期格式: {args.due_date}")
                    return 1
            
            # 添加任务
            success, message, task = self.task_service.add_task(
                title=args.title,
                description=args.description,
                priority=args.priority,
                category=args.category,
                due_date=due_date
            )
            
            if success:
                print(f"✅ {message}")
                print(f"📝 任务详情: {task}")
                return 0
            else:
                print(f"❌ {message}")
                return 1
                
        except Exception as e:
            print(f"❌ 添加任务失败: {str(e)}")
            return 1
    
    def _handle_list(self, args) -> int:
        """处理列出任务命令"""
        try:
            # 构建过滤条件
            filters = {}
            
            if args.status:
                filters['status'] = args.status
            if args.priority:
                filters['priority'] = args.priority
            if args.category:
                filters['category'] = args.category
            if args.overdue:
                filters['overdue'] = True
            if args.upcoming:
                filters['upcoming'] = True
                filters['upcoming_days'] = args.upcoming
            if args.today:
                filters['today'] = True
            if args.date_from:
                date_from = parse_date_input(args.date_from)
                if not date_from:
                    print(f"❌ 无效的开始日期格式: {args.date_from}")
                    return 1
                filters['due_date_start'] = date_from
            if args.date_to:
                date_to = parse_date_input(args.date_to)
                if not date_to:
                    print(f"❌ 无效的结束日期格式: {args.date_to}")
                    return 1
                filters['due_date_end'] = date_to
            
            # 排序设置
            filters['sort_by'] = args.sort
            filters['sort_direction'] = 'DESC' if args.reverse else 'ASC'
            
            # 分页处理
            if hasattr(args, 'page') and args.page > 1:
                tasks, pagination = self.task_service.get_tasks_with_pagination(
                    page=args.page,
                    page_size=args.limit,
                    filters=filters
                )
                
                if not tasks:
                    print("📭 没有找到任务")
                    return 0
                
                # 显示任务列表
                self._display_task_list(tasks)
                
                # 显示分页信息
                self._display_pagination_info(pagination)
                
            else:
                # 普通列表显示
                if args.limit:
                    filters['limit'] = args.limit
                
                tasks = self.task_service.advanced_search(filters)
                
                if not tasks:
                    print("📭 没有找到任务")
                    return 0
                
                # 显示任务列表
                self._display_task_list(tasks)
                
                # 显示统计信息
                total_tasks = self.task_service.advanced_search({k: v for k, v in filters.items() if k not in ['limit']})
                total_count = len(total_tasks)
                if len(tasks) < total_count:
                    print(f"\n📊 显示 {len(tasks)} / {total_count} 个任务")
            
            return 0
            
        except Exception as e:
            print(f"❌ 获取任务列表失败: {str(e)}")
            return 1
    
    def _handle_edit(self, args) -> int:
        """处理编辑任务命令"""
        try:
            # 验证任务 ID
            valid, msg = validate_task_id(args.id)
            if not valid:
                print(f"❌ {msg}")
                return 1
            
            # 构建更新数据
            updates = {}
            if args.title:
                updates['title'] = args.title
            if args.description is not None:
                updates['description'] = args.description
            if args.priority:
                updates['priority'] = args.priority
            if args.status:
                updates['status'] = args.status
            if args.category is not None:
                updates['category'] = args.category
            if args.due_date:
                due_date = parse_date_input(args.due_date)
                if not due_date:
                    print(f"❌ 无效的日期格式: {args.due_date}")
                    return 1
                updates['due_date'] = due_date
            
            if not updates:
                print("❌ 没有指定要更新的字段")
                return 1
            
            # 更新任务
            success, message = self.task_service.edit_task(args.id, **updates)
            
            if success:
                print(f"✅ {message}")
                # 显示更新后的任务
                task = self.task_service.get_task(args.id)
                if task:
                    print(f"📝 更新后: {task}")
                return 0
            else:
                print(f"❌ {message}")
                return 1
                
        except Exception as e:
            print(f"❌ 编辑任务失败: {str(e)}")
            return 1
    
    def _handle_delete(self, args) -> int:
        """处理删除任务命令"""
        try:
            # 验证任务 ID
            valid, msg = validate_task_id(args.id)
            if not valid:
                print(f"❌ {msg}")
                return 1
            
            # 获取任务信息
            task = self.task_service.get_task(args.id)
            if not task:
                print(f"❌ 任务 {args.id} 不存在")
                return 1
            
            # 确认删除
            if not args.force:
                print(f"📝 要删除的任务: {task}")
                confirm = input("❓ 确定要删除这个任务吗？(y/N): ").strip().lower()
                if confirm not in ['y', 'yes', '是']:
                    print("❌ 取消删除")
                    return 0
            
            # 删除任务
            success, message = self.task_service.delete_task(args.id)
            
            if success:
                print(f"✅ {message}")
                return 0
            else:
                print(f"❌ {message}")
                return 1
                
        except Exception as e:
            print(f"❌ 删除任务失败: {str(e)}")
            return 1
    
    def _handle_complete(self, args) -> int:
        """处理完成任务命令"""
        return self._handle_status_change(args.id, 'completed', '完成')
    
    def _handle_start(self, args) -> int:
        """处理开始任务命令"""
        return self._handle_status_change(args.id, 'in_progress', '开始')
    
    def _handle_reopen(self, args) -> int:
        """处理重新打开任务命令"""
        return self._handle_status_change(args.id, 'todo', '重新打开')
    
    def _handle_status_change(self, task_id: int, new_status: str, action_name: str) -> int:
        """处理状态变更的通用方法"""
        try:
            # 验证任务 ID
            valid, msg = validate_task_id(task_id)
            if not valid:
                print(f"❌ {msg}")
                return 1
            
            # 更新状态
            success, message = self.task_service.edit_task(task_id, status=new_status)
            
            if success:
                print(f"✅ 任务{action_name}成功")
                # 显示更新后的任务
                task = self.task_service.get_task(task_id)
                if task:
                    print(f"📝 {task}")
                return 0
            else:
                print(f"❌ {message}")
                return 1
                
        except Exception as e:
            print(f"❌ {action_name}任务失败: {str(e)}")
            return 1
    
    def _handle_search(self, args) -> int:
        """处理搜索任务命令"""
        try:
            # 验证搜索关键词
            valid, msg = validate_search_keyword(args.keyword)
            if not valid:
                print(f"❌ {msg}")
                return 1
            
            # 构建搜索过滤条件
            filters = {
                'search': args.keyword,
                'search_fields': args.fields,
                'sort_by': 'created_at',
                'sort_direction': 'DESC'
            }
            
            # 添加额外过滤条件
            if args.status:
                filters['status'] = args.status
            if args.priority:
                filters['priority'] = args.priority
            if args.limit:
                filters['limit'] = args.limit
            
            # 执行搜索
            tasks = self.task_service.advanced_search(filters)
            
            if not tasks:
                print(f"🔍 没有找到包含 '{args.keyword}' 的任务")
                return 0
            
            print(f"🔍 搜索 '{args.keyword}' 找到 {len(tasks)} 个任务:")
            self._display_task_list(tasks)
            
            return 0
            
        except Exception as e:
            print(f"❌ 搜索任务失败: {str(e)}")
            return 1
    
    def _handle_filter(self, args) -> int:
        """处理高级过滤命令"""
        try:
            # 构建过滤条件
            filters = {}
            
            if args.status:
                filters['status'] = args.status
            if args.priority:
                filters['priority'] = args.priority
            if args.category:
                filters['category'] = args.category
            if args.keyword:
                filters['search'] = args.keyword
            if args.date_from:
                date_from = parse_date_input(args.date_from)
                if not date_from:
                    print(f"❌ 无效的开始日期格式: {args.date_from}")
                    return 1
                filters['due_date_start'] = date_from
            if args.date_to:
                date_to = parse_date_input(args.date_to)
                if not date_to:
                    print(f"❌ 无效的结束日期格式: {args.date_to}")
                    return 1
                filters['due_date_end'] = date_to
            if args.overdue:
                filters['overdue'] = True
            if args.upcoming:
                filters['upcoming'] = True
                filters['upcoming_days'] = args.upcoming
            if args.today:
                filters['today'] = True
            
            # 排序设置
            filters['sort_by'] = args.sort
            filters['sort_direction'] = 'DESC' if args.reverse else 'ASC'
            
            # 分页处理
            if args.page > 1:
                tasks, pagination = self.task_service.get_tasks_with_pagination(
                    page=args.page,
                    page_size=args.limit,
                    filters=filters
                )
                
                if not tasks:
                    print("📭 没有找到匹配的任务")
                    return 0
                
                # 显示过滤条件
                self._display_filter_summary(filters)
                
                # 显示任务列表
                self._display_task_list(tasks)
                
                # 显示分页信息
                self._display_pagination_info(pagination)
                
            else:
                # 普通过滤显示
                if args.limit:
                    filters['limit'] = args.limit
                
                tasks = self.task_service.advanced_search(filters)
                
                if not tasks:
                    print("📭 没有找到匹配的任务")
                    return 0
                
                # 显示过滤条件
                self._display_filter_summary(filters)
                
                # 显示任务列表
                self._display_task_list(tasks)
                
                # 显示统计信息
                total_tasks = self.task_service.advanced_search({k: v for k, v in filters.items() if k not in ['limit']})
                total_count = len(total_tasks)
                if len(tasks) < total_count:
                    print(f"\n📊 显示 {len(tasks)} / {total_count} 个匹配任务")
            
            return 0
            
        except Exception as e:
            print(f"❌ 高级过滤失败: {str(e)}")
            return 1
    
    def _handle_show(self, args) -> int:
        """处理显示任务详情命令"""
        try:
            # 验证任务 ID
            valid, msg = validate_task_id(args.id)
            if not valid:
                print(f"❌ {msg}")
                return 1
            
            # 获取任务
            task = self.task_service.get_task(args.id)
            if not task:
                print(f"❌ 任务 {args.id} 不存在")
                return 1
            
            # 显示详细信息
            self._display_task_detail(task)
            
            return 0
            
        except Exception as e:
            print(f"❌ 获取任务详情失败: {str(e)}")
            return 1
    
    def _handle_stats(self, args) -> int:
        """处理统计信息命令"""
        try:
            stats = self.task_service.get_task_statistics()
            
            print("📊 任务统计信息")
            print("=" * 40)
            print(f"📋 总任务数: {stats.get('total', 0)}")
            print(f"⏳ 待办任务: {stats.get('todo', 0)}")
            print(f"🔄 进行中任务: {stats.get('in_progress', 0)}")
            print(f"✅ 已完成任务: {stats.get('completed', 0)}")
            print(f"📈 完成率: {stats.get('completion_rate', 0)}%")
            print()
            print("🎯 优先级分布:")
            print(f"🔴 高优先级: {stats.get('high_priority', 0)}")
            print(f"🟡 中优先级: {stats.get('medium_priority', 0)}")
            print(f"🟢 低优先级: {stats.get('low_priority', 0)}")
            
            # 显示过期和即将到期的任务
            overdue_count = stats.get('overdue_count', 0)
            upcoming_count = stats.get('upcoming_count', 0)
            
            if overdue_count > 0:
                print(f"\n⚠️  过期任务: {overdue_count} 个")
            
            if upcoming_count > 0:
                print(f"📅 即将到期: {upcoming_count} 个")
            
            return 0
            
        except Exception as e:
            print(f"❌ 获取统计信息失败: {str(e)}")
            return 1
    
    def _handle_export(self, args) -> int:
        """处理导出任务命令"""
        try:
            success, message, data = self.task_service.export_tasks(args.format)
            
            if not success:
                print(f"❌ {message}")
                return 1
            
            # 保存到文件
            if args.output:
                output_file = args.output
            else:
                timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
                output_file = f"tasks_export_{timestamp}.{args.format}"
            
            try:
                with open(output_file, 'w', encoding='utf-8') as f:
                    f.write(data)
                
                print(f"✅ {message}")
                print(f"📁 已保存到: {output_file}")
                return 0
                
            except Exception as e:
                print(f"❌ 保存文件失败: {str(e)}")
                return 1
                
        except Exception as e:
            print(f"❌ 导出任务失败: {str(e)}")
            return 1
    
    def _handle_clean(self, args) -> int:
        """处理清理已完成任务命令"""
        try:
            # 获取已完成任务数量
            completed_tasks = self.task_service.list_tasks(status='completed')
            
            if not completed_tasks:
                print("📭 没有已完成的任务需要清理")
                return 0
            
            # 确认清理
            if not args.force:
                print(f"📋 找到 {len(completed_tasks)} 个已完成的任务:")
                for task in completed_tasks[:5]:  # 只显示前5个
                    print(f"   {task}")
                if len(completed_tasks) > 5:
                    print(f"   ... 还有 {len(completed_tasks) - 5} 个任务")
                
                confirm = input("❓ 确定要删除所有已完成的任务吗？(y/N): ").strip().lower()
                if confirm not in ['y', 'yes', '是']:
                    print("❌ 取消清理")
                    return 0
            
            # 清理任务
            deleted_count = self.task_service.clean_completed_tasks()
            
            if deleted_count > 0:
                print(f"✅ 已清理 {deleted_count} 个已完成的任务")
                return 0
            else:
                print("❌ 清理失败")
                return 1
                
        except Exception as e:
            print(f"❌ 清理任务失败: {str(e)}")
            return 1
    
    def _handle_interactive(self, args) -> int:
        """处理交互模式命令"""
        print("🎮 进入交互模式")
        print("输入 'help' 查看可用命令，输入 'quit' 退出")
        print("=" * 40)
        
        while True:
            try:
                command = input("\n📝 请输入命令: ").strip()
                
                if not command:
                    continue
                
                if command.lower() in ['quit', 'exit', 'q']:
                    print("👋 退出交互模式")
                    break
                
                if command.lower() == 'help':
                    self._show_interactive_help()
                    continue
                
                # 解析并执行命令
                try:
                    args_list = command.split()
                    self.run(args_list)
                except SystemExit:
                    # argparse 会调用 sys.exit，我们需要捕获它
                    pass
                
            except KeyboardInterrupt:
                print("\n👋 退出交互模式")
                break
            except Exception as e:
                print(f"❌ 命令执行失败: {str(e)}")
        
        return 0
    
    def _handle_import(self, args) -> int:
        """处理数据导入命令"""
        try:
            if not os.path.exists(args.file):
                print(f"❌ 文件不存在: {args.file}")
                return 1
            
            # 自动检测文件格式
            file_format = args.format
            if not file_format:
                if args.file.lower().endswith('.json'):
                    file_format = 'json'
                elif args.file.lower().endswith('.csv'):
                    file_format = 'csv'
                else:
                    print("❌ 无法检测文件格式，请使用 --format 参数指定")
                    return 1
            
            print(f"📥 开始导入 {file_format.upper()} 文件: {args.file}")
            print(f"🔄 合并模式: {args.mode}")
            
            # 执行导入
            if file_format == 'json':
                success, message, stats = self.data_manager.import_from_json(args.file, args.mode)
            elif file_format == 'csv':
                success, message, stats = self.data_manager.import_from_csv(args.file, args.mode)
            else:
                print(f"❌ 不支持的文件格式: {file_format}")
                return 1
            
            if success:
                print(f"✅ {message}")
                if stats:
                    print("📊 导入统计:")
                    print(f"   总计: {stats.get('total', 0)} 个任务")
                    print(f"   成功导入: {stats.get('imported', 0)} 个")
                    print(f"   跳过: {stats.get('skipped', 0)} 个")
                    print(f"   更新: {stats.get('updated', 0)} 个")
                    if stats.get('errors', 0) > 0:
                        print(f"   错误: {stats.get('errors', 0)} 个")
                return 0
            else:
                print(f"❌ {message}")
                return 1
                
        except Exception as e:
            print(f"❌ 导入失败: {str(e)}")
            return 1
    
    def _handle_backup(self, args) -> int:
        """处理数据备份命令"""
        try:
            print("💾 开始创建数据备份...")
            
            success, message, backup_path = self.data_manager.create_backup(args.output)
            
            if success:
                print(f"✅ {message}")
                print(f"📁 备份文件: {backup_path}")
                
                # 显示备份文件大小
                if os.path.exists(backup_path):
                    size = os.path.getsize(backup_path)
                    size_mb = size / (1024 * 1024)
                    print(f"📏 文件大小: {size_mb:.2f} MB")
                
                return 0
            else:
                print(f"❌ {message}")
                return 1
                
        except Exception as e:
            print(f"❌ 备份失败: {str(e)}")
            return 1
    
    def _handle_restore(self, args) -> int:
        """处理数据恢复命令"""
        try:
            if not os.path.exists(args.file):
                print(f"❌ 备份文件不存在: {args.file}")
                return 1
            
            print(f"🔄 开始恢复数据备份: {args.file}")
            print(f"🔄 恢复模式: {args.mode}")
            
            if args.mode == 'replace':
                confirm = input("⚠️  替换模式将删除所有现有数据，确定继续吗？(y/N): ").strip().lower()
                if confirm not in ['y', 'yes', '是']:
                    print("❌ 取消恢复")
                    return 0
            
            success, message, stats = self.data_manager.restore_backup(args.file, args.mode)
            
            if success:
                print(f"✅ {message}")
                if stats:
                    print("📊 恢复统计:")
                    if 'backup_info' in stats and stats['backup_info']:
                        backup_info = stats['backup_info']
                        print(f"   备份创建时间: {backup_info.get('created_at', '未知')}")
                        print(f"   备份任务数量: {backup_info.get('task_count', '未知')}")
                    print(f"   恢复任务数: {stats.get('tasks_restored', 0)} 个")
                return 0
            else:
                print(f"❌ {message}")
                return 1
                
        except Exception as e:
            print(f"❌ 恢复失败: {str(e)}")
            return 1
    
    def _handle_report(self, args) -> int:
        """处理数据报告命令"""
        try:
            print(f"📊 生成 {args.type} 报告...")
            
            success, message, report_data = self.data_manager.generate_report(args.type)
            
            if not success:
                print(f"❌ {message}")
                return 1
            
            # 显示报告
            if args.format == 'txt':
                self._display_report_text(report_data, args.type)
            else:
                report_json = json.dumps(report_data, ensure_ascii=False, indent=2)
                print(report_json)
            
            # 保存到文件
            if args.output:
                try:
                    with open(args.output, 'w', encoding='utf-8') as f:
                        if args.format == 'txt':
                            self._write_report_text(f, report_data, args.type)
                        else:
                            json.dump(report_data, f, ensure_ascii=False, indent=2)
                    
                    print(f"\n📁 报告已保存到: {args.output}")
                    
                except Exception as e:
                    print(f"⚠️ 保存报告失败: {str(e)}")
            
            return 0
            
        except Exception as e:
            print(f"❌ 生成报告失败: {str(e)}")
            return 1
    
    def _handle_maintain(self, args) -> int:
        """处理数据库维护命令"""
        try:
            if not args.cleanup and not args.optimize:
                print("❌ 请指定维护操作: --cleanup 或 --optimize")
                return 1
            
            if args.cleanup:
                print("🧹 开始数据库清理...")
                success, message, stats = self.data_manager.cleanup_database()
                
                if success:
                    print(f"✅ {message}")
                    if stats:
                        print("📊 清理统计:")
                        print(f"   删除已完成任务: {stats.get('completed_tasks_removed', 0)} 个")
                        if stats.get('database_optimized'):
                            print("   数据库已优化")
                else:
                    print(f"❌ {message}")
                    return 1
            
            if args.optimize:
                print("⚡ 优化数据库...")
                try:
                    # 通过任务DAO访问数据库管理器
                    db_manager = self.task_service.task_dao.db
                    db_manager.execute_query("VACUUM")
                    db_manager.execute_query("ANALYZE")
                    print("✅ 数据库优化完成")
                except Exception as e:
                    print(f"❌ 数据库优化失败: {str(e)}")
                    return 1
            
            return 0
            
        except Exception as e:
            print(f"❌ 数据库维护失败: {str(e)}")
            return 1
    
    def _show_interactive_help(self):
        """显示交互模式帮助"""
        print("""
🎮 交互模式命令帮助:

📝 任务管理:
  add "任务标题" [-p 优先级] [-c 分类] [-d 截止日期]
  list [--status 状态] [--priority 优先级] [--category 分类]
  edit ID [-t 标题] [-p 优先级] [-s 状态] [-c 分类]
  delete ID [-f]
  show ID

🔄 状态管理:
  complete ID    - 完成任务
  start ID       - 开始任务
  reopen ID      - 重新打开任务

🔍 查询功能:
  search "关键词"
  filter --priority high medium --category 工作
  stats

📤 数据管理:
  export json|csv [-o 文件名]
  import 文件路径 [--mode skip|update|replace]
  backup [-o 备份文件]
  restore 备份文件 [--mode merge|replace]
  report summary|detailed|productivity
  clean [-f]

❓ 其他:
  help  - 显示此帮助
  quit  - 退出交互模式
        """)
    
    def _display_task_list(self, tasks):
        """显示任务列表"""
        if not tasks:
            return
        
        print("\n📋 任务列表:")
        print("-" * 80)
        
        for task in tasks:
            # 状态图标
            status_icon = settings.get_status_icon(task.status)
            priority_icon = settings.get_priority_icon(task.priority)
            
            # 格式化标题
            title = truncate_text(task.title, 40)
            
            # 格式化日期
            due_date_str = format_date(task.due_date) if task.due_date else "无"
            
            # 分类信息
            category_str = f"[{task.category}]" if task.category else ""
            
            # 过期标记
            overdue_mark = "⚠️" if task.is_overdue() else ""
            
            print(f"{status_icon} [{task.id:3d}] {priority_icon} {title:<40} {category_str:<12} 📅{due_date_str:<12} {overdue_mark}")
        
        print("-" * 80)
    
    def _display_task_detail(self, task):
        """显示任务详细信息"""
        print(f"\n📝 任务详情 (ID: {task.id})")
        print("=" * 50)
        print(f"📌 标题: {task.title}")
        print(f"📄 描述: {task.description or '无'}")
        print(f"🎯 优先级: {settings.get_priority_icon(task.priority)} {settings.get_priority_label(task.priority)}")
        print(f"📊 状态: {settings.get_status_icon(task.status)} {settings.get_status_label(task.status)}")
        print(f"🏷️  分类: {task.category or '无'}")
        print(f"📅 截止日期: {format_date(task.due_date) if task.due_date else '无'}")
        print(f"🕐 创建时间: {format_date(task.created_at, 'datetime')}")
        print(f"🔄 更新时间: {format_date(task.updated_at, 'datetime')}")
        
        # 显示额外信息
        if task.due_date:
            days_until = task.days_until_due()
            if days_until is not None:
                if days_until < 0:
                    print(f"⚠️  已过期 {abs(days_until)} 天")
                elif days_until == 0:
                    print("⚠️  今天到期")
                else:
                    print(f"📅 还有 {days_until} 天到期")
        
        print("=" * 50)
    
    def _display_pagination_info(self, pagination):
        """显示分页信息"""
        print(f"\n📄 第 {pagination['current_page']} 页，共 {pagination['total_pages']} 页")
        print(f"📊 显示 {len(pagination)} 个任务，总共 {pagination['total_count']} 个")
        
        nav_info = []
        if pagination['has_prev']:
            nav_info.append("← 上一页")
        if pagination['has_next']:
            nav_info.append("下一页 →")
        
        if nav_info:
            print(f"🔄 导航: {' | '.join(nav_info)}")
    
    def _display_filter_summary(self, filters):
        """显示过滤条件摘要"""
        conditions = []
        
        if 'status' in filters:
            status_list = filters['status'] if isinstance(filters['status'], list) else [filters['status']]
            conditions.append(f"状态: {', '.join(status_list)}")
        
        if 'priority' in filters:
            priority_list = filters['priority'] if isinstance(filters['priority'], list) else [filters['priority']]
            conditions.append(f"优先级: {', '.join(priority_list)}")
        
        if 'category' in filters:
            category_list = filters['category'] if isinstance(filters['category'], list) else [filters['category']]
            conditions.append(f"分类: {', '.join(category_list)}")
        
        if 'search' in filters:
            conditions.append(f"关键词: '{filters['search']}'")
        
        if 'due_date_start' in filters or 'due_date_end' in filters:
            date_range = []
            if 'due_date_start' in filters:
                date_range.append(f"从 {filters['due_date_start']}")
            if 'due_date_end' in filters:
                date_range.append(f"到 {filters['due_date_end']}")
            conditions.append(f"日期范围: {' '.join(date_range)}")
        
        if filters.get('overdue'):
            conditions.append("过期任务")
        
        if filters.get('upcoming'):
            days = filters.get('upcoming_days', 7)
            conditions.append(f"未来 {days} 天内到期")
        
        if filters.get('today'):
            conditions.append("今天的任务")
        
        if conditions:
            print(f"🔍 过滤条件: {' | '.join(conditions)}")
            print("-" * 60)
    
    def _display_report_text(self, report_data, report_type):
        """以文本格式显示报告"""
        print(f"\n📊 {report_type.upper()} 报告")
        print("=" * 50)
        print(f"生成时间: {report_data.get('generated_at', '')}")
        print()
        
        if report_type == 'summary':
            overview = report_data.get('overview', {})
            print("📋 概览:")
            print(f"  总任务数: {overview.get('total', 0)}")
            print(f"  待办任务: {overview.get('todo', 0)}")
            print(f"  进行中任务: {overview.get('in_progress', 0)}")
            print(f"  已完成任务: {overview.get('completed', 0)}")
            print(f"  完成率: {overview.get('completion_rate', 0)}%")
            
            categories = report_data.get('categories', {})
            if categories:
                print("\n🏷️  分类统计:")
                for category, stats in categories.items():
                    print(f"  {category}: {stats['completed']}/{stats['total']} ({stats['completion_rate']}%)")
            
            overdue = report_data.get('overdue_tasks', 0)
            upcoming = report_data.get('upcoming_tasks', 0)
            if overdue > 0:
                print(f"\n⚠️  过期任务: {overdue} 个")
            if upcoming > 0:
                print(f"📅 即将到期: {upcoming} 个")
        
        elif report_type == 'productivity':
            print(f"✅ 总完成任务: {report_data.get('total_completed', 0)}")
            
            avg_time = report_data.get('avg_completion_time_days')
            if avg_time is not None:
                print(f"⏱️  平均完成时间: {avg_time} 天")
            
            most_productive = report_data.get('most_productive_day')
            if most_productive:
                print(f"🏆 最高效日期: {most_productive[0]} ({most_productive[1]} 个任务)")
            
            most_category = report_data.get('most_productive_category')
            if most_category:
                print(f"🎯 最高效分类: {most_category[0]} ({most_category[1]} 个任务)")
        
        print("=" * 50)
    
    def _write_report_text(self, file, report_data, report_type):
        """将报告写入文本文件"""
        file.write(f"{report_type.upper()} 报告\n")
        file.write("=" * 50 + "\n")
        file.write(f"生成时间: {report_data.get('generated_at', '')}\n\n")
        
        if report_type == 'summary':
            overview = report_data.get('overview', {})
            file.write("概览:\n")
            file.write(f"  总任务数: {overview.get('total', 0)}\n")
            file.write(f"  待办任务: {overview.get('todo', 0)}\n")
            file.write(f"  进行中任务: {overview.get('in_progress', 0)}\n")
            file.write(f"  已完成任务: {overview.get('completed', 0)}\n")
            file.write(f"  完成率: {overview.get('completion_rate', 0)}%\n")
            
            categories = report_data.get('categories', {})
            if categories:
                file.write("\n分类统计:\n")
                for category, stats in categories.items():
                    file.write(f"  {category}: {stats['completed']}/{stats['total']} ({stats['completion_rate']}%)\n")


def main():
    """CLI 主函数"""
    cli = TaskCLI()
    return cli.run()


if __name__ == "__main__":
    sys.exit(main())
